I'm still inside of my code cell component, taking a look at the U.S. fact function to remember inside
of here we call crepe bundle twice.
One was to handle the initial render of our component, and the second one was the bounce logic.
Whenever we call Crepe Bundle, the first argument is going to Garcelle ID, the second is going to
be the actual code we want to bundle now rather than attempting to bundle Selldorff content.
We really want to bundle.
You might have code just one very small thing.
Remember, cumulative code is an array of strings, and whenever we call rebundle bundle, the expectation
is we're going to provide one single string.
So for both of our action creators, we're going to update that second argument to be imitative oad,
we're going to join all those strings together with a new line character, the notice the board.
And that's really just going to add in a kind of return or entered, same as if you return on your keyboard,
it's going to join all those code snippets together.
I'm going to update the second one as well.
And also join it with a new character.
And then finally, we need to make sure that we just update our dependency rate down here and we need
to say that we want to attempt to rebundle this code any time cumulative code changes in some way.
I'm going to also put in there a cumulative code, not join with Newline character.
Now, at this point, time for all three references to cumulative code we are adding in or doing a joint
operation with Newline character, so you might think, hey, why don't we just do this joint operation
back up inside of our type selector?
Well, there's a very good reason for that.
You'll see in just a moment.
Right now, just leave in these joint statements.
All right, let's save this look back over.
I'm going to do a quick refresh.
And now inside my very first cell, I should be able to do something like a equals one.
Go down to the second one and add a console log of a.
I'm going to remove the Texel in the middle just to make sure I can see all the code, and now you'll
notice that we do, in fact, end up with a console right there.
So we are now sharing variables or essentially sharing functions or whatever else between these different
code cells.
If I make an update to come up here, I'm going to rebundle both cells.
The second one is going to once again do a console log of the value of a and I see an updated console
log right here of blah, blah, blah.
All right, well, that's kind of it, believe it or not, at a very simple level, we've now got kind
of cumulative code execution throughout all of our different code cells.
Any time we change this code cell, all the independent code cells.
So essentially everything beneath it are going to automatically update as well and execute.
So this is pretty good.
As usual, let's pause right here and continue on in just a moment.