No worries! Very well done video. Very informative. There's a lot of beginner content on KZfaq but not as much architectural content, so I really appreciate you sharing your take on the subject. Just subscribed! Looking forward to more of this kind of content 😁

You realise you can cut the gaps out in the KZfaq creators studio without any need to reupload, don't you?

So I'll just ... children. 😁

Same here, using Context at deep level sounds like a nice idea. But as many others have pointed out, it comes with its own challenges of tightly coupled component that could have been mistaken for "NOT TO BE REUSED AT OTHER PLACES".

Awesome, glad it was useful 👌

Thank you! You should also take a look at Radix to see how a similar approach is used in practice.

True, this and hidden data flows are the reason I tend to avoid the Context API.

Correct, also gosh !! if anyone is using vanilla js with react good luck accessing/handling those product attributes after change in product's attributes.

Agreed, I'm definitely going to apply the idea about Component Composition, but the rest of the video sounds like it's better for demo projects to look as "clean" as possible rather than for real-world code. I'm more likely to use , and and other similar lower-level components as children rather than , and . It's a lot more flexible and it's still very readable.

Context helps those composition components which are grouped and enter linked like Select & Option.

Thanks, I'm glad it was helpful!

Thanks!

Thank you! 🙏

Thanks, I appreciate the kind words!

What is the real composition?

This comment is underrated. You also turned each of these components required to be used within a context. Instead of using props, makes the sole use of the component to be within the product card component. It its also very hard to test, as you need to mock a context in order to be able to test the components instead of simple passing props to the components youre testing. Props > context api. This is simply over engineered

@@ChristianMoentest Valid point, and I do not advice using this pattern everywhere. It's very helpful for building design systems, especially public libraries as this prevents unintended usage and simplifies the API for the user. The testing is indeed a bit harder, though I don't see much point in testing the sub-components individually as small and simple as they usually are.

@@codevincas So for me, a real composition would be something like Settings. If the internal components are just a fancy way to set props it's just an over complicated configuration method IMO.

1. How do they become more complex? You create a context and wrap a Root component around the Provider. You can create all your components in a single file-is it really that hard to maintain a scoped context? 2. Why does it matter which components are allowed? Order shouldn't be important. You're creating arbitrary restrictions that makes it harder to reuse for other cases. You're making up an API which takes _more_ effort to implement than just accepting any component. If your intent is to map over the children to stuff props onto them or filter out, then don't. That's what compound components solve for you. Compound components makes decisions easier at the consumer level, rather than implementation level, making them great for reusability. 3. I don't get this. The compound component is just a component built up of other components, whether it provides a context or not. Each component defines their own props. That said, this is by no means a recommendation that you should make everything a compound component. It's still more effort than just making a special-case component that does what it needs. However, they are a great abstraction when you want more flexibility without imposing restrictions and unnecessary implementation details.

I'm just learning React but wouldn't memo solve those performance concerns you talked about?

@@davien001 Yes it would, but at the same time you will have to maintain multiple memos instead of having a single memoization step for the entire component.

Absolutely agreed, I'm trying to get better with every video. Do you have suggestions in mind for what I should work on?

@@codevincas I noticed one black screen during the video (4:56). The rest is already pointed by @the stunning iitian.

@@Mong3 Indeed, good point, I totally missed the blank section, sorry about that 😅

Glad you enjoyed, but don't refactor unless you absolutely need to.

Thank you! Anything you would like to see me cover?

@@codevincas I think, You could make a video on code optimization in React app.

Could you provide some of the draw backs please?

@@xacxdcx for starters it’s got no lateral reusability

They're all using the same context. I don't recommend using this pattern everywhere, only when flexibility that it gives you is actually benefitial.

@@dealloc then you might as well stick to props drilling or use redux/recoil

@Code With Vincas Yes, I know they are, but now you want to create something completely different, and to keep the design pattern consistent, you need to make a new context for this completely different component. In which it makes it a bit more complicated and increases the difficulty of readability Nice tutorial, though 👌

You could, and for most components that's totally acceptable, and anything more would be overengineering. As I mentioned in the beginning of the video - what happens when you want to slightly change the appearance of the component, for instance hide some parts of it or add a small bit of logic? You'd add boolean flags and change the component implementation logic to accommodate for them. That's fine while there aren't that many flags - most components never reach that point, so that's ok. But particularly design system components are often used in multiple different ways with slight tweaks for each use case. In that case changing the implementation of the component becomes risky and cumbersome, also the component's implementation logic would grow to support all those different use cases and the prop list would be mostly a bunch of boolean flags. Just passing in an object doesn't help in that case, because it doesn't change the need for those flags and in many cases design system components won't even be using a domain model (the object), but rather generic props to retain flexibility. In that case, composable components are superior. If you want to use the context and compound components - that's your decision, in many cases it would be over-engineering, but in some, they're a nice way to group components together.

There's nothing stopping you from doing that, though I would probably create wrapper components for different use cases instead, and leave the composable components as a lower level API.

@@codevincas that makes sense, loved this content btw, cant wait to see more from you

Huh, it works well for me, but I notice that StackBlitz is not booting up the demo on Mobile and Incognito mode - maybe that's what's happening for you?

@@codevincas it seems to be working now, not sure why it was not loading earlier, thanks for checking it!

Awesome, thanks! I'll make sure to condense the typing in the next one.