The WordPress coreCoreCore is the set of software required to run WordPress. The Core Development Team builds WordPress. development team builds WordPress! Follow this site for general updates, status reports, and the occasional code debate. There’s lots of ways to contribute:
Found a bugbugA bug is an error or unexpected result. Performance improvements, code optimization, and are considered enhancements, not defects. After feature freeze, only bugs are dealt with, with regressions (adverse changes from the previous version) being the highest priority.?Create a ticket in our bug tracker.
With 6.1 well underway, here’s the initial schedule of 6.1 bugbugA bug is an error or unexpected result. Performance improvements, code optimization, and are considered enhancements, not defects. After feature freeze, only bugs are dealt with, with regressions (adverse changes from the previous version) being the highest priority. scrub sessions. These 6.1-specific ticketticketCreated for both bug reports and feature development on the bug tracker. scrubs will happen each week until the final release.
BetaBetaA pre-release of software that is given out to a large group of users to trial under real conditions. Beta versions have gone through alpha testing in-house and are generally fairly close in look, feel and function to the final product; however, design changes often occur as part of the process. Scrubs:
RCrelease candidateOne of the final stages in the version release cycle, this version signals the potential to be a final release to the public. Also see alpha (beta). Scrubs:
Check this schedule often, as it will change to reflect the latest information.
What about recurring component scrubs and triagetriageThe act of evaluating and sorting bug reports, in order to decide priority, severity, and other factors. sessions?
The above 6.1 scheduled bug scrubs are separate and in addition.
For your reference, here are some of the recurring sessions:
Design Scrub: Every Tuesday, 16:00 UTC, in the #design channel.
Have a recurring component scrub or triage session? PingPingThe act of sending a very small amount of data to an end point. Ping is used in computer science to illicit a response from a target server to test it’s connection. Ping is also a term used by Slack users to @ someone or send them a direct message (DM). Users might say something along the lines of “Ping me when the meeting starts.”@audrasjb or @chaion07 on SlackSlackSlack is a Collaborative Group Chat Platform https://slack.com/. The WordPress community has its own Slack Channel at https://make.wordpress.org/chat/. to have it added to this page.
Want to lead a bug scrub?
Did you know that anyone can lead a bug scrub at anytime? Yes, you can!
How? Ping @audrasjb or @chaion07 on slack and let us know the day and time you’re considering as well as the report or tickets you want to scrub.
Planning one that’s 6.1-focused? Awesome! It can be added to the schedule above. You’ll get well deserved props in the weekly Dev Chat, as well as in the #props Slack channel!
Where can you find tickets to scrub?
Report 5 provides a list of all open 6.1 tickets:
Use this list to focus on highest priority tickets first.
Use this list to focus on tickets that haven’t received love in a while.
Report 6 provides a list of open 6.1 tickets ordered by workflow.
Need a refresher on bug scrubs? Checkout Leading Bug Scrubs in the coreCoreCore is the set of software required to run WordPress. The Core Development Team builds WordPress. handbook.
Questions?
Have a question, concern, or suggestion? Want to lead a bug scrub? Please leave a comment or reach out directly to @audrasjb or @chaion07 on slack.
I’ve added a new tracking issue for Fluid typography and ongoing enhancements.
Work on the Style Engine has paused during 6.1. I’ll provide an update on planned iterations for 2022/23 in a future agenda.
Open Floor
@tellthemachines commented last week:
I can’t be present at the chat because of timezones, but would like to bring up the “Key project updates” list in the agenda:
Is this approach working? How useful is it for folks?
How can we make sure to keep it up to date?
“Keeping it up to date well that can be a bit tricky as there is probably various amounts of work being done in each tracking issue each week.” – @paaljoachim
“It would be helpful if authors of tracking issues could on occasion drop by and give a general update of how a specific issue is coming along” – @paaljoachim
“hi, i’m just testing WordPress 6.1-RC1-54503, and I still cannot see inner container in group blockBlockBlock is the abstract term used to describe units of markup that, composed together, form the content or layout of a webpage using the WordPress editor. The idea combines concepts of what in the past may have achieved with shortcodes, custom HTML, and embed discovery into a single consistent API and user experience.” referring to this issue, and that it was supposed to be merged for RCrelease candidateOne of the final stages in the version release cycle, this version signals the potential to be a final release to the public. Also see alpha (beta). 1.
“I thought I’d bring up a request from @glorialchemica, which will be a speaker at WordCampWordCampWordCamps are casual, locally-organized conferences covering everything related to WordPress. They're one of the places where the WordPress community comes together to teach one another what they’ve learned throughout the year and share the joy. Learn more. Italia 2022 and is preparing a talk about using patterns.She ran into a problem while trying to use patterns on a test site, and wrote a request on this channel, who that got unnoticed so far. Is there anybody who can look into this or direct her to the right channel she can ask about this?”
“Sometimes I get the problem when I try to use a pattern or block going from an older site to a new site. now I don’t know which version the pattern directory is running on. So, the next steps I would suggest, file an issue / bugbugA bug is an error or unexpected result. Performance improvements, code optimization, and are considered enhancements, not defects. After feature freeze, only bugs are dealt with, with regressions (adverse changes from the previous version) being the highest priority. report on the GutenbergGutenbergThe Gutenberg project is the new Editor Interface for WordPress. The editor improves the process and experience of creating new content, making writing rich content much simpler. It uses ‘blocks’ to add richness rather than shortcodes, custom HTML etc. https://wordpress.org/gutenberg/ repo. Answer all the questions in the issue template. Then check out when the next metaMetaMeta is a term that refers to the inside workings of a group. For us, this is the team that works on internal WordPress sites like WordCamp Central and Make WordPress. team meeting is also DM me when it’s posted, so I can take another look and see if I can reproduce” — @bph
“The error should be shown in the browser console, so it might be a good idea to submit an issue with the error message, WordPress version, your theme” — @wildworks
To get more details go directly to the Open Floor discussions in the CoreCoreCore is the set of software required to run WordPress. The Core Development Team builds WordPress. Editor SlackSlackSlack is a Collaborative Group Chat Platform https://slack.com/. The WordPress community has its own Slack Channel at https://make.wordpress.org/chat/. channel.
“What’s new in GutenbergGutenbergThe Gutenberg project is the new Editor Interface for WordPress. The editor improves the process and experience of creating new content, making writing rich content much simpler. It uses ‘blocks’ to add richness rather than shortcodes, custom HTML etc. https://wordpress.org/gutenberg/…” posts (labeled with the #gutenberg-new tagtagA directory in Subversion. WordPress uses tags to store a single snapshot of a version (3.6, 3.6.1, etc.), the common convention of tags in version control systems. (Not to be confused with post tags.)) are posted following every Gutenberg release on a biweekly basis, discovering new features included in each release. As a reminder, here’s an overview of different ways to keep up with Gutenberg and the Full Site Editing project.
Gutenberg 14.3 has been released and is available for download!
It continues to build on recent writing flow improvements, refines image blockBlockBlock is the abstract term used to describe units of markup that, composed together, form the content or layout of a webpage using the WordPress editor. The idea combines concepts of what in the past may have achieved with shortcodes, custom HTML, and embed discovery into a single consistent API and user experience. creation via drag-n-drop, adds an enhanced tools panel to the Styles interface, and much more!
Continuing on from the improvements to writing flow in the last release. Gutenberg 14.3 includes support for alt + arrow keyboard combinations to make navigating blocks of text a breeze.
For example, if your cursor is towards the end of a long paragraph, you can quickly press alt + up arrow to move to the beginning of that paragraph. If you are already at the beginning of a text block, you’ll move to the start of the previous paragraph. Similarly, alt + down arrow will move you to the end of a block of text.
Improved drag and drop for images
As of Gutenberg 14.3, you can now drop an image onto an empty paragraph block to replace it with a new Image block.
Improved tools panels for the Styles typography controls
Building on past releases, Gutenberg 14.3 now brings the Tools Panels to the Styles interface. This makes the Styles interface consistent with the Block Settings interface, but it also makes it more usable by being able to reset values and opens the door to adding hidden-by-default controls, too!
Query LoopLoopThe Loop is PHP code used by WordPress to display posts. Using The Loop, WordPress processes each post to be displayed on the current page, and formats it according to how it matches specified criteria within The Loop tags. Any HTML or PHP code in the Loop will be processed on each post. https://codex.wordpress.org/The_Loop.: Hide instructions for FormTokenField. (44641)
Tag Cloud: Remove strtolower around taxonomyTaxonomyA taxonomy is a way to group things together. In WordPress, some common taxonomies are category, link, tag, or post format. https://codex.wordpress.org/Taxonomies#Default_Taxonomies. name. (16112)
ToolsPanel: Add subheadings and reset text to tools panel menu. (44260)
Block APIAPIAn API or Application Programming Interface is a software intermediary that allows programs to interact with each other and share data in limited, clearly defined ways.
WP_HTML_Tag_Processor: Inject dynamic data to block HTMLHTMLHyperText Markup Language. The semantic scripting language primarily used for outputting content in web browsers. markup in PHPPHPThe web scripting language in which WordPress is primarily architected. WordPress requires PHP 5.6.20 or higher. (42485)
Bug Fixes
Add a correct TS signature for useEntityRecords. (44448)
BlockDraggable: Change prop name passed to children when dragging is disabled. (44371)
Fix Lint warning/errors in cherry-pick script. (44662)
Fix: Content blocks with nested blocks always appear as top level. (44098)
Hide the Classic block in the Site Editor. (44554)
PHP 8.2: Remove deprecated callable in Style Engine value functions. (44561)
Persisted preferences: Fix context property of user metaMetaMeta is a term that refers to the inside workings of a group. For us, this is the team that works on internal WordPress sites like WordCamp Central and Make WordPress. configuration. (44489)
Resizable editor: Fix height setting bugbugA bug is an error or unexpected result. Performance improvements, code optimization, and are considered enhancements, not defects. After feature freeze, only bugs are dealt with, with regressions (adverse changes from the previous version) being the highest priority.. (44637)
Style engine: Kebab case preset slugs in the editor. (44406)
Add submenu block href only if URLURLA specific web address of a website or web page on the Internet, such as a website’s URL www.wordpress.org is not empty. (44337)
Update Theme JSONJSONJSON, or JavaScript Object Notation, is a minimal, readable format for structuring data. It is used primarily to transmit data between a server and web application, as an alternative to XML.$schema to allow pseudo selectors on button property. (44303)
Preserve the generic signature of getEntityRecord and getEntityRecords through currying. (44453)
Template editor: Fix crashes due to undefined vars. (44482)
Add missing value to CSSCSSCascading Style Sheets. font-display descriptor in theme.json. (44622)
useMergeRefs: Don’t call/mutate refs passed if unused. (44629)
Block Library
Code Block: Add box-sizing to fix inconsistent layout. (44580)
Comment Author: Fix empty links created for the author’s name. (44650)
Comments: Support nested comments settings in the comments blocks. (44351)
Group: Legacy Group inner block wrapper should work with a constrained layout. (44660)
Image: Fix rotated image crop area aspect ratio. (44425)
Image: Upgrade reactReactReact is a JavaScript library that makes it easy to reason about, construct, and maintain stateless and stateful user interfaces. https://reactjs.org/.-easy-crop to bring in fix for site editor iframeiframeiFrame is an acronym for an inline frame. An iFrame is used inside a webpage to load another HTML document and render it. This HTML document may also contain JavaScript and/or CSS which is loaded at the time when iframe tag is parsed by the user’s browser.. (44408)
Navigation: Try fixing link color in some TT2 contexts. (44578)
Paragraph: Disable drop cap control if text is aligned. (42326)
Post Featured ImageFeatured imageA featured image is the main image used on your blog archive page and is pulled when the post or page is shared on social media. The image can be used to display in widget areas on your site or in a summary list of posts.: Fix borders after addition of overlay feature. (44286)
Post Featured Image: Fix application of default border style in editor. (44520)
Query Loop: Fix condition for displaying ‘parents’ control. (44630)
Query Loop: Rename Query Loop variations allowControls to allowedControls. (44523)
Quote block: Stop slash inserter popup showing in the citation. (44634)
Site Title: Fix link color not being applied in editor #37071. (44333)
Template part: Prevent adding block in post editor or inside post template or content blocks. (44480)
Video: Don’t display placeholder SVG when Video block selected. (44564)
Global Styles
Fix empty color indicator with a custom style. (44364)
Re-add styles that were removed for classic themes. (44334)
Remove border from Global Styles previews. (44556)
Spacing presets: Modify the styling of the input controls when in unlinked mode in order to better differentiate sides. (44141)
Navigator Screen: Fix bug where focus moved erroneously. (44239)
Block Editor
Fix block search for non-Latin characters. (44652)
Prevent empty block toolbars from showing empty slots. (44704)
Widgets Editor
Add extra guarding against legacy widgetWidgetA WordPress Widget is a small block that performs a specific function. You can add these widgets in sidebars also known as widget-ready areas on your web page. WordPress widgets were originally created to provide a simple and easy-to-use way of giving design and structure control of the WordPress theme to the user. preview errors. (44635)
Theme export: Stop slugs being cast to integers when a theme is exported. (44589)
AccessibilityAccessibilityAccessibility (commonly shortened to a11y) refers to the design of products, devices, services, or environments for people with disabilities. The concept of accessible design ensures both “direct access” (i.e. unassisted) and “indirect access” meaning compatibility with a person’s assistive technology (for example, computer screen readers). (https://en.wikipedia.org/wiki/Accessibility)
TokenInput field: Try alternative approach to fix screen reader focus issue. (44526)
CS: Always use parentheses when instantiating objects. (44550)
CS: Remove redundant parentheses for include/require statements. (44544)
CS: Use pre-increment instead of post-increment. (44549)
Fix comment typo in document generation tools. (44583)
I18ni18nInternationalization, or the act of writing and preparing code to be fully translatable into other languages. Also see localization. Often written with a lowercase i so it is not confused with a lowercase L or the numeral 1. Often an acquired skill.: Use consistent string: ‘Link rel’. (20162)
PHP 8.2 | Fix deprecated embedded variables in text strings. (44538)
PHP 8.2 | Fix for partially supported callback. (44537)
Remove unnecessary view.js file from navigation-submenu block. (44570)
PluginPluginA plugin is a piece of software containing a group of functions that can be added to a WordPress website. They can extend functionality or add new features to your WordPress websites. WordPress plugins are written in the PHP programming language and integrate seamlessly with WordPress. These can be free in the WordPress.org Plugin Directory https://wordpress.org/plugins/ or can be cost-based plugin from a third-party
Move wp_enqueue_block_view_script to experiments. (44414)
Layout
BackportbackportA port is when code from one branch (or trunk) is merged into another branch or trunk. Some changes in WordPress point releases are the result of backporting code from trunk to the release branch. code quality changes from coreCoreCore is the set of software required to run WordPress. The Core Development Team builds WordPress. to Gutenberg. (44661)
Parsing
Block Serialization Default Parser: Bring back no-more-tokens type. (44459)
Global Styles
Add blocks to the list of valid origins for theme.json. (44363)
Lodash
Lodash: Remove completely from @wordpress/compose package. (44568)
Lodash: Remove completely from @wordpress/library-export-default-webpack-plugin package. (44571)
Lodash: Remove completely from @wordpress/list-reusable-blocks package. (44567)
Popover: Convert unit tests to TypeScript and modern RTL assertions. (44373)
Refactor AlignmentMatrixControl tests to use @testing-library/react. (44670)
End-to-end Test Utils: Don’t use hardcoded login credentials. (44331)
Refactor PluginPostPublishPanel tests to use RTL render. (44667)
Refactor AutosaveMonitor tests to @testing-library/react. (44492)
Refactor PostPreviewButton tests to @testing-library/react. (44470)
Refactor BlockSwitcher tests to @testing-library/react. (44493)
Refactor ResponsiveBlockControl tests to use @testing-library/react. (44669)
Style engine: Add JSJSJavaScript, a web scripting language typically executed in the browser. Often used for advanced user interfaces and behaviors. unit tests for outline properties. (44518)
wp-env: Use case insensitive regex when checking WP version string. (44887)
Performance Benchmark
The following benchmark compares performance for a particularly sizeable post (~36,000 words, ~1,000 blocks) over the last releases. Such a large post isn’t representative of the average editing experience but is adequate for spotting variations in performance.
Post Editor
Version
Loading Time
KeyPress Event (typing)
Gutenberg 14.3
14.3s
79.51ms
Gutenberg 14.2
12.6s
76.31ms
WordPress 6.0
9.8s
41.28ms
Site Editor
Version
Loading Time
KeyPress Event (typing)
Gutenberg 14.3
10.8s
72.89ms
Gutenberg 14.2
10.3s
66.83ms
WordPress 6.0
7.5s
36.81ms
Contributors
The following contributors merged PRs in this release:
WordPress 6.1 Release Candidaterelease candidateOne of the final stages in the version release cycle, this version signals the potential to be a final release to the public. Also see alpha (beta). 1 is out and it’s time to take a look at what changes we can expect. Release squad and many contributors worked hard on both TracTracAn open source project by Edgewall Software that serves as a bug tracker and project management tool for WordPress. and GitHubGitHubGitHub is a website that offers online implementation of git repositories that can easily be shared, copied and modified by other developers. Public repositories are free to host, private repositories require a paid subscription. GitHub introduced the concept of the ‘pull request’ where code changes done in branches by contributors can be reviewed and discussed before being merged be the repository owner. https://github.com/; with more than 120 enhancements and feature requests, 241 bug fixes, 42 other blessed tasks, which makes it over 400 tickets in Trac; and 50 Trac pull requests bringing GutenbergGutenbergThe Gutenberg project is the new Editor Interface for WordPress. The editor improves the process and experience of creating new content, making writing rich content much simpler. It uses ‘blocks’ to add richness rather than shortcodes, custom HTML etc. https://wordpress.org/gutenberg/ changes into coreCoreCore is the set of software required to run WordPress. The Core Development Team builds WordPress.. In Gutenberg repo there were 1684 pull requests of which 425 new features and enhancements and 428 bugbugA bug is an error or unexpected result. Performance improvements, code optimization, and are considered enhancements, not defects. After feature freeze, only bugs are dealt with, with regressions (adverse changes from the previous version) being the highest priority. fixes, while the rest is tooling, testings, documentation, and code quality.
New release comes with massive performance improvements, accessibilityAccessibilityAccessibility (commonly shortened to a11y) refers to the design of products, devices, services, or environments for people with disabilities. The concept of accessible design ensures both “direct access” (i.e. unassisted) and “indirect access” meaning compatibility with a person’s assistive technology (for example, computer screen readers). (https://en.wikipedia.org/wiki/Accessibility) enhancements, first default blockBlockBlock is the abstract term used to describe units of markup that, composed together, form the content or layout of a webpage using the WordPress editor. The idea combines concepts of what in the past may have achieved with shortcodes, custom HTML, and embed discovery into a single consistent API and user experience. based themes marked as accessibility ready, new hooksHooksIn WordPress theme and development, hooks are functions that can be applied to an action or a Filter in WordPress. Actions are functions performed when a certain event occurs in WordPress. Filters allow you to modify certain functions. Arguments used to hook both filters and actions look the same. and functions, private functions being open for public use and many more.
Performance
With 45 Trac tickets for 6.1, 19 components got various performance improvements. The most significant improvements arrived in WP_Query and REST APIREST APIThe REST API is an acronym for the RESTful Application Program Interface (API) that uses HTTP requests to GET, PUT, POST and DELETE data. It is how the front end of an application (think “phone app” or “website”) can communicate with the data store (think “database” or “file system”) https://developer.wordpress.org/rest-api/., which will impact a large portion of your next page load.
If there is one thing you take from performance updates, let it be caching queries in WP_Query. It’s been a long dream for many developers and, once you test it, it will be all that you hoped for. REST API is richer for several priming caches and lighter for prepare_links (if you want it). Site Health will check your Persistent Object Cache and Page Cache, while several private Cache APIAPIAn API or Application Programming Interface is a software intermediary that allows programs to interact with each other and share data in limited, clearly defined ways. functions are now public. You’ll also be able to flush cache by group, declare supported cache features, validate cache keys and more.
Besides Query, REST API, Site Health, and Cache API, performance improvements can be found in MultisitemultisiteUsed to describe a WordPress installation with a network of multiple blogs, grouped by sites. This installation type has shared users tables, and creates separate database tables for each blog (wp_posts becomes wp_0_posts). See also network, blog, site, Bootstrap, Media, Post (Post Types), Editor, Database and many other components. There are too many changes to mention them all here, but you are invited to read the Field guideField guideThe field guide is a type of blogpost published on Make/Core during the release candidate phase of the WordPress release cycle. The field guide generally lists all the dev notes published during the beta cycle. This guide is linked in the about page of the corresponding version of WordPress, in the release post and in the HelpHub version page. on performance improvements in WordPress 6.1.
Posts, Post Types – Post title should not be translatable in get_user_data_from_wp_global_styles method. #55392
Quick/Bulk Edit – Check the show_in_quick_edittaxonomyTaxonomyA taxonomy is a way to group things together. In WordPress, some common taxonomies are category, link, tag, or post format. https://codex.wordpress.org/Taxonomies#Default_Taxonomies. property when processing the data for bulk edited posts. #42474
RevisionsRevisionsThe WordPress revisions system stores a record of each saved draft or published update. The revision system allows you to see what changes were made in each revision by dragging a slider (or using the Next/Previous buttons). The display indicates what has changed in each revision. – Use latest_id as the array key for the latest revision ID. #55857
Accessibility
Similar to performance, accessibility improvements arrive in 28 Trac tickets, spread over 13 components. We have first block-based bundled themes marked with accessibility readytagtagA directory in Subversion. WordPress uses tags to store a single snapshot of a version (3.6, 3.6.1, etc.), the common convention of tags in version control systems. (Not to be confused with post tags.), Twenty Twenty-Three and Twenty Twenty-Two. Forms, site/template and block editors, administration screens and many more accessibility improvements are coming in with 6.1 release.
Among many changes in these 10 releases of the pluginPluginA plugin is a piece of software containing a group of functions that can be added to a WordPress website. They can extend functionality or add new features to your WordPress websites. WordPress plugins are written in the PHP programming language and integrate seamlessly with WordPress. These can be free in the WordPress.org Plugin Directory https://wordpress.org/plugins/ or can be cost-based plugin from a third-party, a lot of effort was made in making blocks and other Gutenberg features more available in classic themes, which will ensure easier transition to hybrid and block-based themes.
New ways to extend various parts of block editor tools which were very much needed in everyday development, such as scaffolding block variants with create-block tool, content locking updates, filtering theme.json data, extending Query block, Style Engine, new ReactReactReact is a JavaScript library that makes it easy to reason about, construct, and maintain stateless and stateful user interfaces. https://reactjs.org/. hooks for easier data access, and many more.
Themes are getting more control over styling elements, layout, and navigation while classic themes also get control over block-based template parts and theme.json. Read all about these in dev notesdev noteEach important change in WordPress Core is documented in a developers note, (usually called dev note). Good dev notes generally include:
a description of the change;
the decision that led to this change
a description of how developers are supposed to work with that change.
Dev notes are published on Make/Core blog during the beta phase of WordPress release cycle. Publishing dev notes is particularly important when plugin/theme authors and WordPress developers need to be aware of those changes.In general, all dev notes are compiled into a Field Guide at the beginning of the release candidate phase. below.
Updated Settings and Styles in Theme.jsonJSONJSON, or JavaScript Object Notation, is a minimal, readable format for structuring data. It is used primarily to transmit data between a server and web application, as an alternative to XML.
New server-side filters in WordPress 6.1 will allow hooking into theme.json data (see 56467 and 54251 for more info).
REST API gets nice improvements for /search endpoint as well as pretty-printing JSON responses, which can be added as query parameter but also controlled via rest_json_encode_optionsfilterFilterFilters are one of the two types of Hooks https://codex.wordpress.org/Plugin_API/Hooks. They provide a way for functions to modify data of other functions. They are the counterpart to Actions. Unlike Actions, filters are meant to work in an isolated manner, and should never have side effects such as affecting global variables and output..
Changes in #54788 allow for the muted property to be used in video elements, which solves for content that wishes to autoPlay when a page is viewed.
Database
A file containing the wpdb class is renamed from wp-includes/wp-db.php to wp-includes/class-wpdb.php to conform to the coding standards. If you’ve been including this file directly, do not worry – a new wp-db.php file is created and it’s loading the old, now renamed file. Read more in #56268.
Other developer updates
As mentioned above, WordPress 6.1 comes with a serious number of new hooks and functions, which will make Miscellaneous dev notedev noteEach important change in WordPress Core is documented in a developers note, (usually called dev note). Good dev notes generally include:
a description of the change;
the decision that led to this change
a description of how developers are supposed to work with that change.
Dev notes are published on Make/Core blog during the beta phase of WordPress release cycle. Publishing dev notes is particularly important when plugin/theme authors and WordPress developers need to be aware of those changes.In general, all dev notes are compiled into a Field Guide at the beginning of the release candidate phase. very useful for theme and plugin developers.
Normalize to Unicode NFC encoding before converting accent characters in remove_accents(). #35951
Cron API
Modify _get_cron_array() to always return an array. #53940
Add error logging and hooks to wp-cron.php. #56048
Editor
Universalize functions for checking block editor status. #51819
Clarify that get_page_template() doesn’t work on block themes. #56394
Block Patterns: Add new Footers categoryCategoryThe 'category' taxonomy lets you group posts / content together that share a common bond. Categories are pre-defined and broad ranging.#56416
External Libraries
Several external libraries have been updated to their latest versions. These include PHPMailer, GetID3, Moment, Sodium Compat, jQuery, jQuery UIUIUser interface, MediaElement.js, Clipboard.js, and Underscore
Add support for WebP images in the Thickbox library. #55786
Normalize to Unicode NFC encoding before converting accent characters in remove_accents()#24661
Replace all esc_url_raw() calls in core with sanitize_url(). #55852
Allow min(), max(), minmax(), and clamp() values to be used in inline CSSCSSCascading Style Sheets.. #55966
KSES: Allow more layout-related CSS properties. #56122
KSES: Allow assigning values to CSS variables. #56353
General
Formatting: Add support for Enums in is_serialized(). #53299
Replace phpversion() function calls with PHP_VERSION constant. #55680
Blocks: Remove duplicate use of realpath() in register_block_style_handle(). #56636
Block Editor: Remove repetitive calls to file_get_contents() in block editor settings. #56637
General: Remove file_exists() checks after calling realpath(). #56654
Blocks: Remove extra get_theme_file_path() calls in register_block_style_handle(). #56666
General: Ensure wp_rand() returns 0 when $min and $max values are equal to 0. #55194
I18Ni18nInternationalization, or the act of writing and preparing code to be fully translatable into other languages. Also see localization. Often written with a lowercase i so it is not confused with a lowercase L or the numeral 1. Often an acquired skill.
I18N: Introduce WP_Textdomain_Registry to store text domains and their language directory paths. #39210
Login and Registration
Required fields in networknetwork(versus site, blog) registration. #54344
Explicitly associate errors with input fields. #54483
WordPress 6.1 introduces several new BlockBlockBlock is the abstract term used to describe units of markup that, composed together, form the content or layout of a webpage using the WordPress editor. The idea combines concepts of what in the past may have achieved with shortcodes, custom HTML, and embed discovery into a single consistent API and user experience.APIAPIAn API or Application Programming Interface is a software intermediary that allows programs to interact with each other and share data in limited, clearly defined ways. features available via the block.json file.
As a recap, the block.json file was introduced in WordPress 5.5 and has been encouraged as the canonical way of registering block types since the WordPress 5.8 release. Many of the recent Block API features, including the ones in this post, depend on block.json being available on the server.
PHPPHPThe web scripting language in which WordPress is primarily architected. WordPress requires PHP 5.6.20 or higher templates for rendering blocks
Before WordPress 6.1, the main output of a block would often be generated in either a JavaScriptJavaScriptJavaScript or JS is an object-oriented computer programming language commonly used to create interactive effects within web browsers. WordPress makes extensive use of JS for a better user experience. While PHP is executed on the server, JS executes within a user’s browser. https://www.javascript.com/.save function, or in a PHP render_callback function.
WordPress 6.1 adds a third way: a separate PHP template file. The path can be specified via the render property of block.json:
{
"render": "file:./render.php"
}
If you don’t have a render_callback setting specified, then the template is used instead. It behaves similarly, but feels much more like traditional WordPress template handling.
The template path is prefixed with file: and relative to the location of the block.json file, following the npm specification.
The render.php template could look like this:
<p <?php echo get_block_wrapper_attributes(); ?>>
<?php esc_html_e( 'Hello from a dynamic block!', 'my-plugin' ); ?>
</p>
Note: The entire file is used as a template, so there’s no need to define additional wrapping functions.
The following variables are available inside the template:
$attributes (array): The block attributes.
$content (string): The block default content.
$block (WP_Block): The block instance.
Use multiple scripts per block
The WordPress 6.1 version enables defining multiple script files in all relevant block.json entries: editScript, script, and viewScript. (Trac #56408) It’s now possible to pass a script handle registered with the wp_register_script function, a path to a JavaScript file relative to the block.json file, or an array with a mix of both:
WordPress maintains a degree of backwards compatibility by passing along only the first (string) item to any existing code working with these values.
Note: Processing a single string requires a different code than processing an array of strings. Therefore, the WP_Block_Type class and the /wp/v2/block-typesREST APIREST APIThe REST API is an acronym for the RESTful Application Program Interface (API) that uses HTTP requests to GET, PUT, POST and DELETE data. It is how the front end of an application (think “phone app” or “website”) can communicate with the data store (think “database” or “file system”) https://developer.wordpress.org/rest-api/. endpoint deprecate accessing string values through their old names: editor_script, script, view_script, editor_style, and style.
The full array of scripts can be accessed via the following new properties of the WP_Block_Type class and the /wp/v2/block-types REST API endpoint:
editor_script_handles,
script_handles,
view_script_handles,
editor_style_handles, and
style_handles.
Furthermore, the scripts and styles registered in block.json will automatically be loaded for static and dynamic blocks in WordPress 6.1. Previously, the dynamic blocks were expected to register their assets.
Combined with the support for multiple stylesheets per block shipped with WordPress 5.9, this change enables developers to use multiple entries for all supported asset types.
Import individual coreCoreCore is the set of software required to run WordPress. The Core Development Team builds WordPress. blocks from @wordpress/block-library
The import of individual core blocks (Pull request #42258) from the @wordpress/block-library npm package was enabled to help developers reduce the bundle size of their applications. Prior to this change, the use of a single core block required pulling in the entire set.
Individual core blocks can be imported in three different ways:
// You can import and automatically register the block:
import '@wordpress/block-library/build-module/verse/init';
// Or you can automatically register the block and reuse the reference:
import verseBlock from '@wordpress/block-library/build-module/verse/init';
// Or you can import the init function without registering the block…
import { init } from '@wordpress/block-library/build-module/verse';
// …and then register the block when needed:
const verseBlock = init();
WordPress 6.1 comes with content-only editing for blocks, patterns, and templates, as well as a template lock inheritance for the Column blockBlockBlock is the abstract term used to describe units of markup that, composed together, form the content or layout of a webpage using the WordPress editor. The idea combines concepts of what in the past may have achieved with shortcodes, custom HTML, and embed discovery into a single consistent API and user experience..
Almost any layout using the coreCoreCore is the set of software required to run WordPress. The Core Development Team builds WordPress. blocks can be composed and shared as a pattern. End users may have found they could accidentally break these layouts or use them in an unexpected way. Previously, the experience of using patterns was not on par with having a specific block for a complex layout.
With WordPress 6.1, a new experimental type of locking has been added called “contentOnly”. This locking method can be used by any pattern or block. When enabled, the users can only change the nested content inside the block/pattern. The block structure starts behaving as a single unit where the block hierarchy is entirely hidden. The user can only change text and media URLs in the blocks.
Additionally, block types without content are hidden from the List View and are unable to gain focus within the block list. This makes it harder to break the expected layout.
In locked mode, the inspector controls of the blocks are also disabled. Instead, the sidebarSidebarA sidebar in WordPress is referred to a widget-ready area used by WordPress themes to display information that is not a part of the main content. It is not always a vertical column on the side. It can be a horizontal rectangle below or above the content area, footer, header, or any where in the theme. only shows a list of content blocks a user can change.
For now, users still have the freedom to leave this locked mode by pressing modify. When modify is pressed, the block editor shows the hierarchy, and the user has complete control. For now, any user can press the modify button. In the future, it may depend on the capabilities of the user.
Content only editing in a block
The core blocks that support content locking are column, cover, and group.
To use content locking, the templateLock attribute of one of the previously referred blocks should be set to “contentOnly”.
In the following pattern, only the content of the paragraph blocks can be edited. A user would not view the spacer block in between.
Paragraph 1
Paragraph 2
Using as custom post-type template locking
The new content-only locking can also be used as custom post-type template locking, like all the other locking methods that exist.
Global template_lock inheritance in the column block
The block template defines a default list of blocks in an editor session. To prevent manipulation of the block list, all blocks can be locked by the template_lock property.
However, in column blocks, the editor would crash on certain operations because it would initialize the lock status defined in the block template. To resolve this issue and to be more consistent about template lock status inheritance, column blocks now inherit the lock status of block templates.
The @wordpress/core-dataJavaScriptJavaScriptJavaScript or JS is an object-oriented computer programming language commonly used to create interactive effects within web browsers. WordPress makes extensive use of JS for a better user experience. While PHP is executed on the server, JS executes within a user’s browser. https://www.javascript.com/. package in 6.1 ships new ReactReactReact is a JavaScript library that makes it easy to reason about, construct, and maintain stateless and stateful user interfaces. https://reactjs.org/.hooksHooksIn WordPress theme and development, hooks are functions that can be applied to an action or a Filter in WordPress. Actions are functions performed when a certain event occurs in WordPress. Filters allow you to modify certain functions. Arguments used to hook both filters and actions look the same. that make accessing WordPress data easier than before.
useEntityRecords
With useEntityRecords developers, can fetch a list of records with a single hook call:
useEntityRecords( 'postType', 'page' )
Below is what it looks like when used in a React component:
import { useEntityRecord } from '@wordpress/core-data';
function PageTitlesList() {
const pages = useEntityRecords( 'postType', 'page' );
if ( pages.isResolving ) {
return 'Loading...';
}
return (
<ul>
{pages.records.map(( page ) => (
<li>{ page.title }</li>
))}
</ul>
);
};
// Rendered in the application:
// <PageTitlesList />
In the above example when PageTitlesList is rendered, the list of records and the resolution details will be retrieved from the store state using getEntityRecords(), or resolved if missing.
The useEntityRecords accepts four arguments:
kind (string) – Kind of the entity, e.g. root or a postType.
name (string) – Name of the entity, e.g. plugin or a post.
queryArgs (object) – Optional HTTPHTTPHTTP is an acronym for Hyper Text Transfer Protocol. HTTP is the underlying protocol used by the World Wide Web and this protocol defines how messages are formatted and transmitted, and what actions Web servers and browsers should take in response to various commands. query to pass to the requested APIAPIAn API or Application Programming Interface is a software intermediary that allows programs to interact with each other and share data in limited, clearly defined ways. endpoint, e.g. { "per_page": 10 }
options (object) – Optional hook options. Currently, the only supported option is enabled and determines whether the records will be requested.
It returns an object with the following properties:
records (array) – The requested entity records
isResolving (boolean) – Are these records being resolved at the moment?
hasResolved (boolean) – Have these records resolved already?
status (string) – Resolution status. One of: IDLE, RESOLVING, SUCCESS, or ERROR
useEntityRecord:
Developers can retrieve a single record using the useEntityRecord hook:
import { useEntityRecord } from '@wordpress/core-data';
function PageTitleDisplay( { id } ) {
const page = useEntityRecord( 'postType', 'page', id );
if ( page.isResolving ) {
return 'Loading...';
}
return page.title;
}
// Rendered in the application:
// <PageTitleDisplay id={ 13 } />
In the above example, when PageTitleDisplay is rendered, the page and the resolution details will be retrieved from the store state using getEntityRecord(), or resolved if missing.
The useEntityRecord hook accepts four arguments:
kind (string) – Kind of the entity, e.g. root or a postType.
name (string) – Name of the entity, e.g. plugin or a post.
recordId (string|number) – The ID of the requested entity record.
options (object) – Optional hook options. Currently, the only supported option is enabled and determines whether the records will be requested.
It returns an object with the following properties:
record (object|null) – The resolved entity record.
isResolving (boolean) – Is the record being resolved at the moment?
hasResolved (boolean) – Has the record already resolved already?
status (string) – Resolution status. One of: IDLE, RESOLVING, SUCCESS, or ERROR.
hasEdits (boolean) – Does the record have any in-browser edits?
editedRecord (object|null) – The record with any in-browser edits applied.
edit (function) – Applies the in-browser edits to the edited entity record.
save (function) – Persist the in-browser edits to the server.
Below is an example showcasing the editing capabilities provided by useEntityRecord:
import { useDispatch } from '@wordpress/data';
import { useCallback } from '@wordpress/element';
import { __ } from '@wordpress/i18n';
import { TextControl } from '@wordpress/components';
import { store as noticeStore } from '@wordpress/notices';
import { useEntityRecord } from '@wordpress/core-data';
function PageRenameForm( { id } ) {
const page = useEntityRecord( 'postType', 'page', id );
const { createSuccessNotice, createErrorNotice } =
useDispatch( noticeStore );
const setTitle = useCallback( ( title ) => {
page.edit( { title } );
}, [ page.edit ] );
if ( page.isResolving ) {
return 'Loading...';
}
async function onRename( event ) {
event.preventDefault();
try {
await page.save();
createSuccessNotice( __( 'Page renamed.' ), {
type: 'snackbar',
} );
} catch ( error ) {
createErrorNotice( error.message, { type: 'snackbar' } );
}
}
return (
<form onSubmit={ onRename }>
<TextControl
label={ __( 'Name' ) }
value={ page.editedRecord.title }
onChange={ setTitle }
/>
<button type="submit">{ __( 'Save' ) }</button>
</form>
);
}
// Rendered in the application:
// <PageRenameForm id={ 1 } />
In the above example, updating and saving the page title is handled via the edit() and save() mutation helpers provided by useEntityRecord();
useResourcePermissions
Developers can check the current user’s permissions using the useResourcePermissions hook:
import { useResourcePermissions } from '@wordpress/core-data';
function Page({ pageId }) {
const pagePermissions = useResourcePermissions( 'pages', pageId );
if ( pagePermissions.isResolving ) {
return 'Loading ...';
}
return (
<div>
{pagePermissions.canCreate
? (+ Create a new page)
: false}
{pagePermissions.canUpdate
? (Edit page)
: false}
{pagePermissions.canDelete
? (Delete page)
: false}
// ...
</div>
);
}
// Rendered in the application:
// <Page pageId={ 15 } />
In the above example when the Page is rendered, the appropriate record-level page permissions and the resolution details will be retrieved from the store state using the canUser() selector, or resolved if missing.
In the following example, the PagesList component requests permissions for the pages collection and not a specific page record:
import { useResourcePermissions } from '@wordpress/core-data';
function PagesList() {
const pagesPermissions = useResourcePermissions( 'pages' );
if ( pagesPermissions.isResolving ) {
return 'Loading ...';
}
return (
<div>
{pagesPermissions.canCreate
? (+ Create a new page)
: false }
// ...
</div>
);
}
// Rendered in the application:
// <PagesList />
The useResourcePermissions hook accepts two arguments:
resource (string) – The resource in question, e.g., media.
id (string|number) – Optional ID of a specific resource entry, e.g., 10.
It returns an object with the following properties:
status (string) – Resolution status. One of: IDLE, RESOLVING, SUCCESS, or ERROR
isResolving (boolean) – Is the record being resolved at the moment?
hasResolved (boolean) – Has the record already resolved?
create (boolean) – Can the current user create new resources of this type?
read (boolean) – Can the current user read resources of this type?
update (boolean) – Only if id is provided. Can the current user update the requested resource?
delete (boolean) – Only if id is provided. Can the current user delete the requested resource?
The meetings take place on Wednesdays at 20:00 UTC in the #core channel on Slack, and usually last an hour. All are welcome to attend or catch up via the summary.
GutenbergGutenbergThe Gutenberg project is the new Editor Interface for WordPress. The editor improves the process and experience of creating new content, making writing rich content much simpler. It uses ‘blocks’ to add richness rather than shortcodes, custom HTML etc. https://wordpress.org/gutenberg/PluginPluginA plugin is a piece of software containing a group of functions that can be added to a WordPress website. They can extend functionality or add new features to your WordPress websites. WordPress plugins are written in the PHP programming language and integrate seamlessly with WordPress. These can be free in the WordPress.org Plugin Directory https://wordpress.org/plugins/ or can be cost-based plugin from a third-party 14.3 is due to land on October 12. Its RC is already available.
Dev Notesdev noteEach important change in WordPress Core is documented in a developers note, (usually called dev note). Good dev notes generally include:
a description of the change;
the decision that led to this change
a description of how developers are supposed to work with that change.
Dev notes are published on Make/Core blog during the beta phase of WordPress release cycle. Publishing dev notes is particularly important when plugin/theme authors and WordPress developers need to be aware of those changes.In general, all dev notes are compiled into a Field Guide at the beginning of the release candidate phase. for 6.1 are in process, going through tech and editorial review, and published as they are ready. Find them at the dev-notes-6-1tagtagA directory in Subversion. WordPress uses tags to store a single snapshot of a version (3.6, 3.6.1, etc.), the common convention of tags in version control systems. (Not to be confused with post tags.). The Field GuideField guideThe field guide is a type of blogpost published on Make/Core during the release candidate phase of the WordPress release cycle. The field guide generally lists all the dev notes published during the beta cycle. This guide is linked in the about page of the corresponding version of WordPress, in the release post and in the HelpHub version page. will be out shortly. Thanks to the efforts led by the release docs team.
Note 1: Double sign-off is needed for tickets with milestone 6.1, no matter trunktrunkA directory in Subversion containing the latest development code in preparation for the next major release cycle. If you are running "trunk", then you are on the latest revision. or branchbranchA directory in Subversion. WordPress uses branches to store the latest development code for each major release (3.9, 4.0, etc.). Branches are then updated with code for any minor releases of that branch. Sometimes, a major version of WordPress and its minor versions are collectively referred to as a "branch", such as "the 4.0 branch"./backportbackportA port is when code from one branch (or trunk) is merged into another branch or trunk. Some changes in WordPress point releases are the result of backporting code from trunk to the release branch.. Note 2: Trunk was not branched on October 11, 2022 following RC1.
If you have an update from release leads or any teams collaborating on related items, please add a comment.
5. Component maintainers updates / tickets / requests for help
Please add your request for tickets you would like to raise as a comment.
With WordPress 6.1, theme developers can style elements with references from other settings.
Theme designs often require consistency in the styles applied to blocks. This can be achieved by setting Styles properties which are inherited by blocks using the inheritance of the CSSCSSCascading Style Sheets. cascade. In some cases blocks want to apply settings from Styles to a different property of the blockBlockBlock is the abstract term used to describe units of markup that, composed together, form the content or layout of a webpage using the WordPress editor. The idea combines concepts of what in the past may have achieved with shortcodes, custom HTML, and embed discovery into a single consistent API and user experience. – for example the button element might want to use the global text color for its background color and the global background for its text color.
To solve this problem, themes need to be able to share Styles settings with blocks. This will make it easier for users to update these shared properties across all their blocks. Again, as example for button element the developer wants to use the text color for its background. If the button element is set up as in the example above, then when a user edits the global text color, the background color of their buttons will also be updated, too.
To achieve this, a new ref property was added to theme.jsonJSONJSON, or JavaScript Object Notation, is a minimal, readable format for structuring data. It is used primarily to transmit data between a server and web application, as an alternative to XML. which allows one property to set itself to the value of another, for example defining this for button elements:
Styles will convert {ref: "styles.color.background"} the value at: styles > color > background in theme.json.
Limitations
It is currently only possible to use ref to get one value from theme.json; a ref value cannot point to another ref. This also prevents circular refs from causing problems.
With WordPress 6.1 around the corner, this post brings together the many accessibilityAccessibilityAccessibility (commonly shortened to a11y) refers to the design of products, devices, services, or environments for people with disabilities. The concept of accessible design ensures both “direct access” (i.e. unassisted) and “indirect access” meaning compatibility with a person’s assistive technology (for example, computer screen readers). (https://en.wikipedia.org/wiki/Accessibility) improvements and fixes to look forward to that might be hard to discover amongst the details of 500+ bugs and enhancements. As always, there’s more work to be done with accessibility requiring an ongoing effort and commitment.
If you’re interested in helping with this work, please join the #accessibility channel in Make SlackSlackSlack is a Collaborative Group Chat Platform https://slack.com/. The WordPress community has its own Slack Channel at https://make.wordpress.org/chat/. (need a slack account to view) and check out how you can get involved. There are numerous ways to get involved in this important work including testing, giving accessibility feedback, and creating PRs to address feedback.
Themes
Most notably, 6.1 will see the introduction of both Twenty Twenty-Two and Twenty Twenty-Three marked as accessibility ready, making them both the first default blockBlockBlock is the abstract term used to describe units of markup that, composed together, form the content or layout of a webpage using the WordPress editor. The idea combines concepts of what in the past may have achieved with shortcodes, custom HTML, and embed discovery into a single consistent API and user experience. themes to do so (and only default block themes). This helps open up more folks to the world of block themes and broader site editing features.
Across the many screens in WP Admin, improvements abound. Changes range from improvements in color contrast on the pluginPluginA plugin is a piece of software containing a group of functions that can be added to a WordPress website. They can extend functionality or add new features to your WordPress websites. WordPress plugins are written in the PHP programming language and integrate seamlessly with WordPress. These can be free in the WordPress.org Plugin Directory https://wordpress.org/plugins/ or can be cost-based plugin from a third-party screen during recovery mode, to a switch from a text input to a textarea field in the media library, so users are better able to see the content of the field while editing.
To better call attention to the many improvements to this form, this section has been pulled out of the WP Admin Screen section. While this is a lesser used interface, the accessibility improvements are quite significant for this release, addressing many longstanding problems. This includes proper labels for required fields, explicitly associating errors with input fields so folks know what actions to take where, improved labels for radio buttons, and more.
Even though the Site and Template editors both use blocks, there are some specific accessibility challenges for these new interfaces in a site editing world. More work is needed and, if you’re keen to help, please join the FSE Outreach Program where you can go through calls for testing to provide feedback, find bugs, and more.
The navigation block continues to be a powerful and complex block, especially in the world of block themes. While there are fallbacks and an improved menu management experience to look forward to in this release, there is also a nice set of accessibility related fixes to make this necessary block usable for more people in more situations.
General Block Editor (other blocks, writing flow, components, etc)
This section covers a wide range of items including everything from improvements to additional blocks, like a focus loss fix for the Table block, and larger improvements to functionality like the Tools Panel. Specifically, the Tools Panel helps power part of the experience of using the numerous design toolspresent in more blocks for this release. It’s what you’d interact with to interact with more tools or reset changes. Improving the accessibility of this single tool has a cascading impact by improving the experience everywhere it’s used.
Comments now include proper contextual attributes for autocomplete fields, proper labels for the visible text describing required fields, and improved accessibility (and translatability) of the logged in as link.
WordPress 6.1 includes an enhancementenhancementEnhancements are simple improvements to WordPress, such as the addition of a hook, a new feature, or an improvement to an existing feature. to the search controller, #56546, which makes it possible to retrieve a term or post object over the REST APIREST APIThe REST API is an acronym for the RESTful Application Program Interface (API) that uses HTTP requests to GET, PUT, POST and DELETE data. It is how the front end of an application (think “phone app” or “website”) can communicate with the data store (think “database” or “file system”) https://developer.wordpress.org/rest-api/. without knowing anything but that resource’s ID and object type.
get_post can retrieve a post of any post type so long as you know the post’s numeric ID, and get_term can retrieve a term from any taxonomyTaxonomyA taxonomy is a way to group things together. In WordPress, some common taxonomies are category, link, tag, or post format. https://codex.wordpress.org/Taxonomies#Default_Taxonomies.. Because REST objects are segregated by post type-specific endpoints, however, there has not been a clear way to get a Post with ID 78 if you don’t know whether it is a page, post, or my-cpt.
The coreCoreCore is the set of software required to run WordPress. The Core Development Team builds WordPress./search endpoint now supports ?include and ?exclude parameters which take a list of IDs, and limit results to posts matching those IDs.
Examples:
To get post 78 when you don’t know its post type,
/wp/v2/search?include=78
To get posts 78 and 79 only if they are in the page post type,
/wp/v2/search?include=78,79&subtype=page
To search posts excluding post 78,
/wp/v2/search?exclude=78
To get term 87,
/wp/v2/search?type=term&include=78
To get term 87 only if it is a categoryCategoryThe 'category' taxonomy lets you group posts / content together that share a common bond. Categories are pre-defined and broad ranging.,
The search endpoint supports the _embedmetaMetaMeta is a term that refers to the inside workings of a group. For us, this is the team that works on internal WordPress sites like WordCamp Central and Make WordPress. parameter, so developers can therefore use the search endpoint to retrieve a full post or term response object in one request knowing only those object’s IDs.
As an example of how this could be used, imagine a custom blockBlockBlock is the abstract term used to describe units of markup that, composed together, form the content or layout of a webpage using the WordPress editor. The idea combines concepts of what in the past may have achieved with shortcodes, custom HTML, and embed discovery into a single consistent API and user experience. which relates to a specific post. As of WordPress 6.1 developers can implement that block knowing only the related post’s ID, and could then create a hook to search for that post by ID and retrieve it using the Block Editor’s existing entity system:
/**
* Dictionary of requested items: keep an in-memory list of the type (if known)
* for each requested ID, to limit unnecessary API requests.
*/
const typeById = {};
/**
* Query for a post entity resource without knowing its post type.
*
* @param {number} id Numeric ID of a post resource of unknown subtype.
* @returns {object|undefined} The requested post object, if found and loaded.
*/
function usePostById( id ) {
const type = typeById[ id ];
useEffect( function() {
if ( ! id || typeById[ id ] ) {
return;
}
apiFetch( {
path: `/wp/v2/search?type=post&include=${ id }&_fields=id,subtype`,
} ).then( ( result ) => {
if ( result.length ) {
typeById[ id ] = result[0].subtype;
}
} );
}, [ id ] );
return useSelect( function( select ) {
if ( ! id || ! type ) {
return undefined;
}
return select( 'core' ).getEntityRecord( 'postType', type, id );
}, [ id, type ] );
}
Pretty-printing REST endpoint JSONJSONJSON, or JavaScript Object Notation, is a minimal, readable format for structuring data. It is used primarily to transmit data between a server and web application, as an alternative to XML. responses
WordPress 6.1 also introduces support for returning pre-formatted JSON from the REST API. #41998 lets developers request formatted JSON using a new _pretty query parameter or a filterFilterFilters are one of the two types of Hooks https://codex.wordpress.org/Plugin_API/Hooks. They provide a way for functions to modify data of other functions. They are the counterpart to Actions. Unlike Actions, filters are meant to work in an isolated manner, and should never have side effects such as affecting global variables and output., particularly useful when querying via curl or other tools which do not provide an option to format responses.
To format the JSON returned from a specific endpoint request, append the ?_pretty query parameter to the endpoint URLURLA specific web address of a website or web page on the Internet, such as a website’s URL www.wordpress.org.
To instruct WordPress to pretty-print all REST response bodies, a developer can use the rest_json_encode_options filter:
