Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Course: Block Development #771

Closed
westnz opened this issue Jun 3, 2022 · 52 comments
Closed

Course: Block Development #771

westnz opened this issue Jun 3, 2022 · 52 comments
Assignees

Comments

@westnz
Copy link
Collaborator

westnz commented Jun 3, 2022

No description provided.

@westnz westnz self-assigned this Jun 3, 2022
@westnz
Copy link
Collaborator Author

westnz commented Jun 3, 2022

Michael Burridge is working on this course and I will be supporting him along the way as Instructional Designer. Here is the initial planning doc: Block Development Course Objectives

@mburridge
Copy link

Thanks Wes.

@azhiya
Copy link
Collaborator

azhiya commented Jun 3, 2022

Michael Burridge is working on this course and I will be supporting him along the way as Instructional Designer. Here is the initial planning doc: Block Development Course Objectives

Hi, @westnz that link requires access. Can we make it read-only for public view?

@westnz
Copy link
Collaborator Author

westnz commented Jun 3, 2022

Thank you @azhiya Michael changed the access to read-only for public view.

@azhiya
Copy link
Collaborator

azhiya commented Jun 3, 2022

@courtneyr-dev courtneyr-dev moved this to 💡 Topic Ideas in LearnWP Content - Development Jun 14, 2022
@westnz westnz changed the title Block Development Course Course: Block Development Jun 17, 2022
@westnz
Copy link
Collaborator Author

westnz commented Jul 13, 2022

COURSE UPDATE

Michael has started building the course in Sensei:

The outline is complete and he has drafted the Introduction and Module 1.

Herewith my feedback so far and recent discussions we have had:

Feedback – Introduction & Getting started module - Wes
Thank you for the wonderful work you have started here. Herewith is some feedback from an educational point of view:

Introduction
I absolutely love how you have laid out the learning journey in the introduction. Students exactly know what to expect, and what they will be learning, and creating. You highlight the progressive sequence of lessons clearly. My only suggestion is to use some bullet points when you mention “So, what will you be building in this course?” to break up the number of paragraphs and highlight it.

What is a block?
Short and sweet. I think we need to look at how to add visually appealing features – here and throughout the course.

I would also suggest using the following blocks to highlight/summarize/emphasize certain points or concepts going forward: Info Callout, Tip Callout and Alert Callout. I noticed you have used the Tip Callout in the Build and run a project lesson. 😃

Set up your development environment
Thorough list!

<should we give instructions for this? Docker is needed.> Yes, I think so
<should we provide instructions on installing these?> Yes
<should we cover using nvm to manage node/npm versions?> I think it is better to cover all our bases.

You mentioned; “Additionally you should know, or be prepared to learn, the basics of React.” Could you add links to more resources for those who are not well-acquainted with React?

Scaffold your first block
The conversational style of writing and the way lessons have been broken into digestible pieces are effective.

I want to pause here and think about how we can engage learners throughout the course by using some techniques like using visuals, storytelling, examples of before and after, compelling dilemmas or asking interesting questions.

Understand the structure of the project
You are really good at explaining things and structuring things in a logical and sequential order. Maybe we could use a Tip Callout to highlight the directories that will probably never be touched.

The video that we will be creating will be helpful here to go through the src directory. Adding too many images here will lead to cognitive overload.

Build and run your project
This page flows very well visually for me. 👍️

Make some simple changes
I assume this is still being worked on.

Michael's response:

Hey Wes, thanks so much for casting an eye over the course as it exists thus far, and for your in-depth comments.

Introduction

My only suggestion is to use some bullet points when you mention “So, what will you be building in this course?”

TBH I think I’d prefer the introduction to have a more conversational flow and a more engaging style.

What is a block?

I think we need to look at how to add visually appealing features

I would also suggest using the following blocks to highlight/summarize/emphasize certain points or concepts going forward

I agree with these points, I’ll revisit this (and probably many other lessons) later on when I’ve got the bulk of the content done to add refinements such as the ones you suggest here. For now I want to get a first draft done that can be revised and iterated on.

Set up your development environment

Could you add links to more resources for those who are not well-acquainted with React?

Done!

Regarding my questions, which you answered in the affirmative, my doubts are about overloading the learner with peripheral information that can be obtained elsewhere. Should we go for “completeness” or keep things tightly focussed on the subject matter we’re addressing?

Scaffold your first block

I want to pause here and think about how we can engage learners throughout the course by using some techniques like using visuals, storytelling, examples of before and after, compelling dilemmas or asking interesting questions.

Great points. Again something that can be addressed when I come to revise the content. For now I’m going to focus on getting as much content in as possible.

Understand the structure of the project

Maybe we could use a Tip Callout to highlight the directories that will probably never be touched.

Good idea. I’ll bear in mind ways in which I can make the content more visually appealing and more easily digestible once I’ve got the first draft down.

For now I’ve changed it to use bullet points just to break up the “monolithic block of text” look.

Make some simple changes
I assume this is still being worked on.

Yup. 😄

Thanks again for giving it the once over Wes, and thanks too for your kind remarks. I’ll bear all your points in mind as I work on future lessons. I guess I’m more or less on the right track so for now I’ll just keep on keeping on.

Wes's feedback:

Absolutely! You are more than on the right track and it makes a lot of sense coming back to add refinements etc.

my doubts are about overloading the learner with peripheral information that can be obtained elsewhere. Should we go for “completeness” or keep things tightly focussed on the subject matter we’re addressing?

Good point. Maybe you could just add the info as a footer at the end of the lesson if you wish to. Something like this:

@westnz
Copy link
Collaborator Author

westnz commented Aug 3, 2022

Update: Michael has now added content to module 2. He hopes to have the text-based part of the course finished by the end of August. 🤞

@mburridge
Copy link

Update: work done in the past two weeks (08 Aug 2022 - 19 Aug 2022)

I encountered a couple of minor bugs in the project as I reconstructed the project for the purposes of creating the course. They were mainly me making coding errors, but they still took a bit of time to track down.

The target for this period was to finish the four lessons that would complete the course up to the end of module 4. The course structure is continually being modified as the content develops and two new lessons were added. I therefore haven’t completed up to the end of module 4 as planned, so the target was not met in that sense, but I did complete four lessons.

The lesson "Conditionally display controls" has been moved to later in the course.

Achievements in this period

  • Resolved some bugs in the project

  • I had a pair-programming session with Ryan in which we finally got the custom NumberControl block working properly – although I did already have a working version there was an annoying interface bug when the user typed directly into the input element instead of using the spinner controls

  • As a result of finally having a fully working version I incorporated the custom NumberControl block into the course – it has been presented in the course as a snippet for the learner to simply copy and paste. How to create a custom component will be reserved for a separate course.

  • Did some more restructuring of the course – two new lessons added:

  • Completed four lessons:

@westnz
Copy link
Collaborator Author

westnz commented Aug 22, 2022

Thank you @mburridge. You sure have put a lot of work into this so far! Well done!!

@westnz
Copy link
Collaborator Author

westnz commented Sep 5, 2022

@mburridge
Copy link

The draft of the Block Development Course is now ready for review. 🎉

Please provide your feedback as a comment here by Thursday, 15 September.

Here's some things to take into account during your review of the course:

  • check for technical accuracy, i.e. have I described or explained something wrongly or used any technical terms wrongly or inappropriately?
  • check the technical explanations and suggest ways of explaining things better or more clearly
  • build the project step by step and ensure that the code works at each step
    • is there a better way to implement any of the code, e.g. more efficient, more accepted, fits better with “best practice”?
  • evaluate whether the course is suitably progressive:
    • that it starts with simple concepts and gradually introduces more complicated concepts
    • no technical concepts are suddenly introduced without previous explanation or out of context
    • that there are no sudden conceptual leaps
    • that the learner is not left confused at any point
  • check that the course is suitably comprehensive, i.e. major concepts needed for learners getting started with block development are all covered
    • yet not overly so, i.e. no unnecessary or over-complicated concepts are introduced that are not suitable for this level of learner
  • grammar and spelling check, i.e. text is clear and there are no typos
  • evaluate the structure of the course, i.e. is each module a coherent block and the lessons within that module are appropriate to it?
  • Suggestions for activities and assessments during the course
  • Suggestions for a better title for the course – ideally the title should be short and snappy yet accurately describe the purpose of the course and its content
  • anything else that I haven’t thought of

Thanks. I'm looking forward to your comments and feedback.

@gziolo
Copy link
Member

gziolo commented Sep 6, 2022

Excellent work @mburridge. I started looking at the course to check how it all fits together and it's an impressive work. I like how you divided it into sections and how you introduce new concepts as the work in the block progresses.

I have some technical feedback to share for the first two modules:

General note, code examples don't follow WordPress Coding Standards. I'm not sure if that is something that is important here or not, but it's noticeable for someone who is forced to follow them on the daily basis.

What is a block?

The block editor, also known as Gutenberg, is the modern replacement for TinyMCE which is the editor that WordPress traditionally came with and with which you may already be familiar.
Although it is an ongoing project still under active development, the block editor is already mature enough to be the default editor in new WordPress installations.

Technically speaking the block editor is the default WordPress editor from WordPress 5.0 (December 2018). Initially, the editor used TinyMCE internally and it was refactored later in the development process. I wouldn't highlight it being strictly a replacement for TinyMCE. It's far more important to emphasize instead the concept of blocks and how it lets users edit every aspect of the WordPress site using a single interface. It isn't posts and pages anymore.

Scaffold your first block

npx @wordpress/create-block multi-columns

Side note here. If you don't provide a name of the plugin/block then Create Block will prompt questions on the terminal and the user is able to customize many things. In effect, instead of manually editing block.json on "Build and run your project" page, they could pick those values when scaffolding the project. It's fine to show how to edit block.json the way it is, but it would be also nice to let folks the tool is more powerful.

Understand the structure of the project

save.js exports a function that determines the markup that will be saved to the post_content field in the wp_posts table when the post or page is saved.

It isn't only a post or page, it's all post types, including templates used by a block theme.

Add ‘Block Supports’ controls

I have mixed feelings when seeing experimental APIs like "__experimentalDefaultControls" in the official educational materials. In general, this is something that is meant to be used only in the Gutenberg plugin. See the recent post on that topic: https://make.wordpress.org/core/2022/08/10/proposal-stop-merging-experimental-apis-from-gutenberg-to-wordpress-core/.

It would be great to figure out how to make this API stable in the upcoming WordPress 6.1 release so everyone could freely use the stable version without this experimental prefix.

Define default settings in block.json

There are a number of components that are marked with __experimental... in Gutenberg,

While this is a great hint, it might feel very confusing for someone who is exposed for the first time to learning about building blocks for WordPress. In the ideal world, we would present how to use only stable APIs so people don't need to learn about all those nuances.

@gziolo
Copy link
Member

gziolo commented Sep 6, 2022

Module 3, 4 & 5

Create custom inspector panel controls

It's a bit painful experience to avoid using useBlockProps and pass styles through style for features that are handled by the block editor. It's fine though as a learning exercise as it gets refactored later. What I'm worried about, it can lead also to subtle bugs if there is any style generated by useBlockProps because the style prop will always override it. I would feel more comfortable seeing this code always passing custom style and className through useBlockProps.

Add more configuration options

I have a similar concern as in the earlier module about using the experimental API that isn't considered ready for production use: __experimentalNumberControl component. Can we avoid using it or find a way to make it stable in WordPress 6.1 first?

Work with the InnerBlocks component

This is my favorite part when inner blocks get introduced ❤️ 🎉

Refining the project

That's really nice to present all the opportunities to simplify the code 💯

Add style variations

I like the idea of showing how to use style variations. There is a drop cap native support in the block editor. It works with Paragraph blocks out of the box. You can look for dropCap in https://github.com/WordPress/gutenberg/blob/trunk/docs/how-to-guides/themes/theme-json.md. The limitation though is that you can't control the drop cap for inner blocks from the parent block.

The finished project

I don't see any experimental APIs included on this page. This is great, I'm wondering why there is a disconnect with the previous modules.

@mburridge
Copy link

mburridge commented Sep 6, 2022

Thanks so much for reviewing the course @gziolo and for your comments and feedback. Thanks also for your very kind remarks.

General note, code examples don't follow WordPress Coding Standards.

The repo for the project is here. Please feel free to submit PRs that bring the code into line with the WordPress Coding Standards (if you have the time) where you discern that it deviates from them and I'll update the tutorial accordingly.

I wouldn't highlight it being strictly a replacement for TinyMCE. It's far more important to emphasize instead the concept of blocks and how it lets users edit every aspect of the WordPress site using a single interface.

Good point. The earlier parts of the course are the ones most in need of revision I think, so I'll factor that in when I come to review and revise the course.

but it would be also nice to let folks the tool is more powerful.

Ideally I'd like to keep the course tightly focused around the project being built and not have too many side avenues to distract the learner. @jonathanbossenger has created a separate tutorial on Create Block which I reference in that lesson. Do you feel that it's important to explain the scope of the tool at that stage of the tutorial?

It isn't only a post or page, it's all post types, including templates used by a block theme

Another good point, I'll take it into account when reviewing and revising.

I have mixed feelings when seeing experimental APIs like "__experimentalDefaultControls"

I agree and have similar misgivings, and as you say this is confusing for the user. I've rewritten the following two lessons to remove all reference to "__experimentalDefaultControls":

Thanks once again for your review.

I see you've just posted another comment above 😄 - I'll address that separately.

@gziolo
Copy link
Member

gziolo commented Sep 6, 2022

General note, code examples don't follow WordPress Coding Standards.

The repo for the project is here. Please feel free to submit PRs that bring the code into line with the WordPress Coding Standards (if you have the time) where you discern that it deviates from them and I'll update the tutorial accordingly.

In theory, you should be able to run the following commands with npm run in the repository:

https://github.com/mburridge/multi-columns/blob/d3833f2eee965f51026b957128aa456408f72c57/package.json#L10-L12

npm run format
npm run lint:css
npm run lint:js

It probably gets the default version of Prettier installed instead of the forked one for WordPress. I guess it's the issue with npm aliases... Yes, I checked package-lock.json file and it resolves to the official Prettier:

"prettier": {
      "version": "2.6.2",
      "resolved": "https://registry.npmjs.org/prettier/-/prettier-2.6.2.tgz",
      "integrity": "sha512-PkUpF+qoXTqhOeWL9fu7As8LXsIUZ1WYaJiY/a7McAQzxjk82OF0tibkFXVCDImZtWxbvojFjerkiLb0/q8mew==",
      "dev": true,
      "peer": true
    },

I guess it's what most people will experience so we have to live with this for now.

but it would be also nice to let folks the tool is more powerful.

Ideally I'd like to keep the course tightly focused around the project being built and not have too many side avenues to distract the learner. @jonathanbossenger has created a separate tutorial on Create Block which I reference in that lesson. Do you feel that it's important to explain the scope of the tool at that stage of the tutorial?

Fair enough 👍🏻

@azhiya
Copy link
Collaborator

azhiya commented Sep 6, 2022

Moving this to "Review in Progress" column.

@azhiya azhiya moved this from 💡 Topic Ideas to 🔎 Review in Progress in LearnWP Content - Development Sep 6, 2022
@mburridge
Copy link

It's a bit painful experience to avoid using useBlockProps and pass styles through style for features that are handled by the block editor. It's fine though as a learning exercise as it gets refactored later. What I'm worried about, it can lead also to subtle bugs if there is any style generated by useBlockProps because the style prop will always override it. I would feel more comfortable seeing this code always passing custom style and className through useBlockProps.

I take your point, but as you observe this is a learning exercise. The presumed audience is developers new to React and maybe even new to JavaScript, having come from a PHP background. I'm trying in the course to introduce concepts gradually and in this instance show them a way to do it that they might already be familiar with, or at least able to understand the code, and then refactor it to show them a more "React way" of doing the same thing which might initially seem conceptually alien.

I don't know, I think this is a better way but I'm open to persuasion that your suggestion of introducing useBlockProps earlier in the course might be better for the learner.

There is a drop cap native support in the block editor. It works with Paragraph blocks out of the box.

Is that theme dependent? When using Twenty Twenty-Two the drop cap doesn't seem to be available. In any case it's a learning exercise and demonstrates how to use is-style-{slug} in the scss file. I couldn't think of another example for a style variation but am open to any ideas you might be able to offer in place of the Drop Cap style variation.

I don't see any experimental APIs included on this page. This is great, I'm wondering why there is a disconnect with the previous modules.

That's coz there aren't any! 😄 The example you mentioned in your earlier comment was a transitory thing which was replaced with a better version in the course. That has been removed now because, as you said, it was confusing for the learner and I now realise it was actually a bit redundant.

The other instance where an experimental component is mentioned is a box out in this lesson where it's referenced in case the learner has come across it elsewhere and they're discouraged from using it. Do you think it's better not to mention it at all?

Thanks for your kind comments on the other items, and thanks again for taking the time to review the course.

@gziolo
Copy link
Member

gziolo commented Sep 9, 2022

It's a bit painful experience to avoid using useBlockProps and pass styles through style for features that are handled by the block editor. It's fine though as a learning exercise as it gets refactored later. What I'm worried about, it can lead also to subtle bugs if there is any style generated by useBlockProps because the style prop will always override it. I would feel more comfortable seeing this code always passing custom style and className through useBlockProps.

I take your point, but as you observe this is a learning exercise. The presumed audience is developers new to React and maybe even new to JavaScript, having come from a PHP background. I'm trying in the course to introduce concepts gradually and in this instance show them a way to do it that they might already be familiar with, or at least able to understand the code, and then refactor it to show them a more "React way" of doing the same thing which might initially seem conceptually alien.

I don't know, I think this is a better way but I'm open to persuasion that your suggestion of introducing useBlockProps earlier in the course might be better for the learner.

I had to check how useBlockProps is documented to have a better overview of why we have a different understanding how this should be explained. This is the code documentation:

https://github.com/WordPress/gutenberg/blob/35f14cc073e97a4c14c01bb5c28ac40944282964/packages/block-editor/src/components/block-list/use-block-props/index.js#L45-L52

This hook is used to lightly mark an element as a block element. The element should be the outermost element of a block. Call this hook and pass the returned props to the element to mark as a block. If you define a ref for the element, it is important to pass the ref to this hook, which the hook in turn will pass to the component through the props it returns. Optionally, you can also pass any other props through this hook, and they will be merged and returned.

This is a way to mark a HTML element as a block wrapper in the editor. It means that this is where all additional HTML attributes get injected to ensure that the block integrates seamlessly with all the UI elements like block toolbar, inspector controls, and related interactions.

The most important code looks as follows:

https://github.com/WordPress/gutenberg/blob/35f14cc073e97a4c14c01bb5c28ac40944282964/packages/block-editor/src/components/block-list/use-block-props/index.js#L145-L171

return {
		tabIndex: 0,
		...wrapperProps,
		...props,
		ref: mergedRefs,
		id: `block-${ clientId }${ htmlSuffix }`,
		role: 'document',
		'aria-label': blockLabel,
		'data-block': clientId,
		'data-type': name,
		'data-title': blockTitle,
		className: classnames(
			// The wp-block className is important for editor styles.
			classnames( 'block-editor-block-list__block', {
				'wp-block': ! isAligned,
				'has-block-overlay': hasOverlay,
			} ),
			className,
			props.className,
			wrapperProps.className,
			useBlockClassNames( clientId ),
			useBlockDefaultClassName( clientId ),
			useBlockCustomClassName( clientId ),
			useBlockMovingModeClassNames( clientId )
		),
		style: { ...wrapperProps.style, ...props.style },
	};

There is a ton happening here, but what's most important is that you better pass all props through this function (yes, it's also React hook) to ensure that the block editor is able to merge everything together.

Now, let me explain a few issues with the code example included like:

    return (
        <>
            <RichText
                {...useBlockProps()}
                tagName="p"
                onChange={onChangeContent}
                value={attributes.content}
                placeholder={__("Enter some text here...")}
                style={{
                    columnCount: attributes.columnCount,
                    color: attributes.style.color.text,
                    background: attributes.style.color.background,
                }}
            />
        </>
    );

useBlockProps returns a long list of props that you can read from the code above including style. The code above also defines style. The way React works is that the last occurrence of the same prop wins, so any style provided from the block editor gets ignored. If you would also pass classname in the addition to that, then it would replace the long list of class names that the block editor needs to work correctly.

The other challenge is that useBlockProps is a React Hook so it needs always run and be in the same order. In effect, it's better to put it before the return statement. In effect, the way to minimize potential mistakes the following would work best in my opinion:

    const blockProps = useBlockProps({
        style={{
            columnCount: attributes.columnCount,
            color: attributes.style.color.text,
            background: attributes.style.color.background,
        }}      
    });
    return (
        <RichText
                {...blockProps}
                tagName="p"
                onChange={onChangeContent}
                value={attributes.content}
                placeholder={__("Enter some text here...")}
            />
    );

The developer experience is suboptimal here because it's hard to explain that className, style and ref have special handling here. It's a tricky one and super confusing, and the same pattern for passing props should apply to useBlockProps.save that is a regular function in save.

Aside: the following code would also work:

    const blockProps = useBlockProps({
        style={{
            columnCount: attributes.columnCount,
            color: attributes.style.color.text,
            background: attributes.style.color.background,
        }}
        tagName="p"
        onChange={onChangeContent}
        value={attributes.content}
        placeholder={__("Enter some text here...")}
    });
    return (
        <RichText {...blockProps} />
    );

I don't think it's used this way for core blocks. It's all about the mental mode where we mix block wrapper props with the props specific to the React element that we enhance. I wish we had a better story for it.

The interesting aspect here is that if we were to pass an id to the RichText component this way and with the previous way, then it would produce a different result. Here the block editor would override the id passed with the one from useBlockProps, but in the previous examples, it would use the id passed directly to RichText and that might have an unpredictable impact on how UI works.


There is a drop cap native support in the block editor. It works with Paragraph blocks out of the box.

Is that theme dependent? When using Twenty Twenty-Two the drop cap doesn't seem to be available. In any case it's a learning exercise and demonstrates how to use is-style-{slug} in the scss file. I couldn't think of another example for a style variation but am open to any ideas you might be able to offer in place of the Drop Cap style variation.

Yes, theme authors can disable certain features, including all other shared controls that are featured in the course. The same thing can happen to colors or padding when they get disabled. The other story is that block style variations need better integration with the features that themes can control with theme.json.


The other instance where an experimental component is mentioned is a box out in this lesson where it's referenced in case the learner has come across it elsewhere and they're discouraged from using it. Do you think it's better not to mention it at all?

I see what you did. You were faster than I was able to process the course 😄 I would keep an eye on that and double-check with folks new to the block development. As I mentioned before, it would be great to show only stable APIs in all educational material and hide experiments for internal usage in the Gutenberg plugin. I also can see how the code copied for the custom React component can work as a way to teach that you can build your controls, too.

@westnz
Copy link
Collaborator Author

westnz commented Oct 18, 2022

@westnz
Copy link
Collaborator Author

westnz commented Sep 1, 2023

Hey @mburridge
We have started asking for feedback from students who complete our courses to help improve our content. One of the questions is: "What can we add or change?".

Please validate feedback: #1835

@mburridge
Copy link

Hi @westnz

Great that you're soliciting feedback. What do you mean by "Please validate feedback"? Do you want me to update the course with the points raised here?

@westnz
Copy link
Collaborator Author

westnz commented Sep 3, 2023

Hey @mburridge

Yes, it is good to get direct feedback from students. If you agree with the feedback and feel it is valid, you could update the course with the points raised. Some feedback might not be valid, actionable, or within the scope of the course. Hope that makes sense.

@courtneyr-dev
Copy link
Collaborator

WP 6.4 WordPress/gutenberg#52579 please review

@courtneyr-dev courtneyr-dev reopened this Sep 27, 2023
@github-project-automation github-project-automation bot moved this from 📜 Published or Closed to 🚧 Drafts in Progress in LearnWP Content - Development Sep 27, 2023
@courtneyr-dev courtneyr-dev added the hacktoberfest To mark issues for the Hacktoberfest event each October. label Oct 2, 2023
@jonathanbossenger
Copy link
Collaborator

@courtneyr-dev do you have anything specific you think needs to be updated on this course due to the Interactivity API? As far as I remember, this course does not use either the File block or Navigation block, which is what the linked Gutenberg issue is about.

@courtneyr-dev
Copy link
Collaborator

@jonathanbossenger I'm not entirely sure but wasn't sure if it was related. In part, it is hard to sus out what is contained within a course when I'm blasting through many GitHub issues. This is part of why it is a challenge to know what inside courses should be updated.

I do think these likely are though:

Key Make Posts/GitHub/Trac Issue(s):
Include Block Hooks in WordPress 6.4 (53987).
Block API: Stabilize Block Hooks feature (54293).
A developer news article is planned for during the 6.4 release cycle to provide up to date documentation.

@kaitohm kaitohm added fields-done and removed Review 1 complete hacktoberfest To mark issues for the Hacktoberfest event each October. labels Dec 5, 2023
@jonathanbossenger
Copy link
Collaborator

The interactivity API will probably land in WordPress in version 6.5. Once that's happened, we can look at adding content about it to one of the developer learning pathways, probably the intermediate plugin developer pathway. Therefore I am closing this ticket for now.

@github-project-automation github-project-automation bot moved this from 🚧 Drafts in Progress to 📜 Published or Closed in LearnWP Content - Development Jan 22, 2024
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Labels
None yet
Projects
Status: 📜 Published or Closed
Development

No branches or pull requests